package com.lecture.java8.stream;


import com.lecture.java8.lambda.entity.User;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @program: spring-lecture
 * @description:
 *
 * 一：stream的三个操作步骤
 *      1：创建stream
 *      2：中间操作
 *      3：终止操作
 *
 * @author: luyn
 * @create: 2020-03-28 11:30
 **/
public class TestStream {

    // 创建stream流
    public void test1() {
        // 1：可以通过collection系列集合提供的stream() 或 parallelStream() 获取
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        // 2：通过Arrays中的静态方法stream()获取数组流
        User[] user = new User[10];
        Stream<User> stream1 = Arrays.stream(user);

        // 3：通过Stream类中的静态方法of()获取
        Stream<List<String>> list1 = Stream.of(list);

        // 4：创建无限流
        // 迭代
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 3);

        /*iterate.limit(10)
                .forEach((item) -> {
            System.out.println(item);
        });*/

        iterate.limit(20)
                .forEach(System.out::println);

        // 生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

    // 中间操作
    /**
     * 筛选与切片
     * filter--接受lambda表达式，从流中排除一些元素
     * limit--截断流，使其元素不超过给定数量
     * skip(n)----跳过元素，返回一个扔掉了前n个元素的流，若流中不足n个元素，则返回一个空流，与limit互补。
     * distinct---筛选，通过流所生成元素的hashCode和equals去除重复元素
     * */
    public void test2() {
        List<User> userList = Arrays.asList(
                new User(1, "张三", 13),
                new User(2, "李四", 72),
                new User(3, "王五", 16),
                new User(4, "赵六", 31),
                new User(5, "薛七", 53)
        );
     /*   userList.stream()
                .filter((user) -> user.getAge() > 2)
                .limit(2)
                .forEach(System.out::println);

        userList.stream()
                .filter((user) -> user.getAge() > 3 && user.getName().equals("张三"))
                .forEach(System.out::println);*/

        List<User> collect = userList.stream()
                .filter((user) -> user.getAge() > 20)
                .sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .collect(Collectors.toList());
       // collect.sort((o1, o2) -> o1.getAge() - o2.getAge());

        collect.forEach(System.out::println);

        List<User> list = userList.stream()
                .filter((user) -> user.getName().equals("张三"))  
                .collect(Collectors.toList());
        System.out.println("------------------------");
        list.forEach(System.out::println);
    }

    /**
     * 映射
     * map--接收lambda，将元素转换成其他形式或提取信息，j接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
     * flatMap---接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流l连接成一个流
     *
     */
    public void test3() {
        List<String> strList = Arrays.asList("fsdfs","ere","sfafff","afdsfsd","erwerwe");
        strList.stream()
                .map(String::toUpperCase)
                    .forEach(System.out::println);
            strList.forEach(System.out::println);
        Map<String, String> map = new HashMap<>();
        map.put("a", "v");
        map.put("b", "v");
        map.forEach((k, v) -> System.out.println(k +":" + v));
    }

    /**
     * 排序
     * sorted()---自然排序
     * sorted(Comparator com)
     */
    public void test4() {
        List<User> userList = Arrays.asList(
                new User(1, "张三", 13),
                new User(2, "李四", 72),
                new User(3, "王五", 16),
                new User(4, "赵六", 31),
                new User(5, "薛七", 53)
        );
        userList.stream()
                .sorted(Comparator.comparingInt(User::getAge))
                .forEach(System.out::println);
    }

    public static void main(String[] args) {
        TestStream testStream = new TestStream();
        //testStream.test1();
        //testStream.test3();
        testStream.test3();
    }
}
